package com.movie.service.impl;

import com.movie.entity.Movie;
import com.movie.entity.Showtime;
import com.movie.mapper.MovieMapper;
import com.movie.mapper.SeatMapper;
import com.movie.mapper.ShowtimeMapper;
import com.movie.service.ShowtimeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ShowtimeServiceImpl implements ShowtimeService {

    @Autowired
    private ShowtimeMapper showtimeMapper;

    @Autowired
    private MovieMapper movieMapper;

    @Autowired
    private SeatMapper seatMapper;

    @Override
    public List<Showtime> getShowtimesByMovieId(Long movieId) {
        // 直接调用 Mapper 方法
        return showtimeMapper.findByMovieId(movieId);
    }

    @Override
    public Showtime getShowtimeById(Long id) {
        // 直接调用 Mapper 方法
        return showtimeMapper.findById(id);
    }

    /**
     * 检查场次时间是否与同一影厅的其他场次冲突
     * @param showtime 要检查的场次
     * @return 如果有冲突返回true，否则返回false
     */
    private boolean hasTimeConflict(Showtime showtime) {
        // 获取电影时长
        Movie movie = movieMapper.findById(showtime.getMovieId());
        if (movie == null) {
            throw new IllegalArgumentException("电影不存在");
        }

        // 计算场次结束时间
        LocalDateTime startTime = showtime.getShowTime();
        LocalDateTime endTime = startTime.plusMinutes(movie.getDuration());

        // 查询是否有冲突的场次
        List<Showtime> conflictingShowtimes = showtimeMapper.findConflictingShowtimes(
            showtime.getHallName(), startTime, endTime, showtime.getId());

        return !conflictingShowtimes.isEmpty();
    }

    @Override
    @Transactional
    public Showtime createShowtime(Showtime showtime) {
        // 基本验证
        if (showtime.getShowTime() == null) {
            throw new IllegalArgumentException("放映时间不能为空");
        }

        if (showtime.getShowTime().isBefore(LocalDateTime.now())) {
            throw new IllegalArgumentException("放映时间必须是未来时间");
        }

        // 检查时间冲突
        if (hasTimeConflict(showtime)) {
            throw new IllegalArgumentException("该影厅在所选时间段内已有其他场次，请选择其他时间或影厅");
        }

        // 调用 Mapper 插入数据
        int insertedRows = showtimeMapper.insert(showtime);
        if (insertedRows > 0) {
            // 插入成功后，showtime 对象应该会包含 MyBatis 返回的自增 ID (如果配置了 useGeneratedKeys)
            return showtime;
        } else {
            // 处理插入失败的情况，可以抛出异常
            throw new RuntimeException("添加场次失败");
        }
    }

    @Override
    public Map<String, Object> getAllShowtimesPaged(int page, int size) {
        int offset = page * size;

        // 获取当前页数据
        List<Showtime> showtimes = showtimeMapper.findAllPaged(offset, size);

        // 获取总数
        int totalElements = showtimeMapper.countAll();

        // 计算总页数
        int totalPages = (int) Math.ceil((double) totalElements / size);

        // 构建返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("content", showtimes);         // 当前页数据
        result.put("totalElements", totalElements); // 总记录数
        result.put("totalPages", totalPages);       // 总页数
        result.put("currentPage", page);            // 当前页码
        result.put("size", size);                   // 每页大小

        return result;
    }

    @Override
    @Transactional // 确保删除操作在事务中进行
    public boolean deleteShowtime(Long id) {
        // 可以先检查是否存在，如果需要区分 "未找到" 和 "删除失败"
        // Showtime existing = showtimeMapper.findById(id); // 假设 Mapper 有 findById
        // if (existing == null) {
        //     return false; // 返回 false 表示未找到
        // }
        // 直接尝试删除，根据影响的行数判断是否成功
        int deletedRows = showtimeMapper.deleteById(id);
        return deletedRows > 0;
    }

    @Override
    @Transactional
    public Showtime updateShowtime(Showtime showtime) {
        // 先检查是否存在
        Showtime existing = showtimeMapper.findById(showtime.getId());
        if (existing == null) {
            return null; // 返回 null 表示未找到
        }

        // 基本验证
        if (showtime.getShowTime() == null) {
            throw new IllegalArgumentException("放映时间不能为空");
        }

        if (showtime.getShowTime().isBefore(LocalDateTime.now())) {
            throw new IllegalArgumentException("放映时间必须是未来时间");
        }

        // 检查时间冲突
        if (hasTimeConflict(showtime)) {
            throw new IllegalArgumentException("该影厅在所选时间段内已有其他场次，请选择其他时间或影厅");
        }

        // 调用 Mapper 更新数据
        int updatedRows = showtimeMapper.update(showtime);
        if (updatedRows > 0) {
            // 更新成功，返回更新后的对象
            return showtimeMapper.findById(showtime.getId());
        } else {
            // 处理更新失败的情况
            throw new RuntimeException("更新场次失败");
        }
    }

    @Override
    @Transactional
    public int updateAvailableSeats(Long showtimeId) {
        // 检查场次是否存在
        Showtime showtime = showtimeMapper.findById(showtimeId);
        if (showtime == null) {
            throw new IllegalArgumentException("场次不存在: " + showtimeId);
        }

        // 统计可用座位数量
        int availableSeats = seatMapper.countAvailableSeats(showtimeId);

        // 更新场次的可用座位数量
        showtimeMapper.updateAvailableSeats(showtimeId, availableSeats);

        return availableSeats;
    }
}